home *** CD-ROM | disk | FTP | other *** search
/ InterCD 2001 May / may_2001.iso / intercd / root / Multimedia / ^DivX_Article / virtualdub / VirtualDub-source-1_4d / wrappedMMIO.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2001-03-20  |  4.1 KB  |  148 lines
  1. //    VirtualDub - Video processing and capture application
  2. //    Copyright (C) 1998-2001 Avery Lee
  3. //
  4. //    This program is free software; you can redistribute it and/or modify
  5. //    it under the terms of the GNU General Public License as published by
  6. //    the Free Software Foundation; either version 2 of the License, or
  7. //    (at your option) any later version.
  8. //
  9. //    This program is distributed in the hope that it will be useful,
  10. //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. //    GNU General Public License for more details.
  13. //
  14. //    You should have received a copy of the GNU General Public License
  15. //    along with this program; if not, write to the Free Software
  16. //    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  
  18. #include <windows.h>
  19. #include <mmsystem.h>
  20.  
  21. #include "Error.h"
  22. #include "wrappedMMIO.h"
  23.  
  24. HMMIO wrappedOpen(char *me, LPSTR szFilename, LPMMIOINFO lpmmioinfo, DWORD dwOpenFlags) {
  25.     HMMIO hmmio;
  26.     MMIOINFO mmi;
  27.  
  28.     if (lpmmioinfo)
  29.         hmmio = mmioOpen(szFilename, lpmmioinfo, dwOpenFlags);
  30.     else {
  31.         memset(&mmi,0,sizeof mmi);
  32.         hmmio = mmioOpen(szFilename, &mmi, dwOpenFlags);
  33.     }
  34.  
  35.     if (!hmmio) //throw "Unable to open file.";
  36.         throw MyMMIOError(me, lpmmioinfo ? lpmmioinfo->wErrorRet : mmi.wErrorRet);
  37.  
  38.     return hmmio;
  39. }
  40.  
  41. void wrappedClose(char *me, HMMIO mmio, UINT flags) {
  42.     MMRESULT err;
  43.  
  44.     if (MMSYSERR_NOERROR != (err = mmioClose(mmio, flags)))
  45.         throw MyMMIOError(me, err);
  46. }
  47.  
  48. void wrappedFlush(char *me, HMMIO mmio, UINT flags) {
  49.     MMRESULT err;
  50.  
  51.     if (MMSYSERR_NOERROR != (err = mmioFlush(mmio, flags)))
  52.         throw MyMMIOError(me, err);
  53. }
  54.  
  55. void wrappedCreateChunk(char *me, HMMIO mmio, MMCKINFO *ckinfo, UINT flags) {
  56.     MMRESULT err;
  57.  
  58.     if (MMSYSERR_NOERROR != (err = mmioCreateChunk(mmio, ckinfo, flags)))
  59. //        throw "Error creating chunk!";
  60.         throw MyMMIOError(me,err);
  61. }
  62.  
  63. void wrappedStartChunk(char *me, HMMIO mmio, MMCKINFO *mmi, FOURCC ckid) {
  64.     mmi->cksize = 0;
  65.     mmi->ckid = ckid;
  66.  
  67.     wrappedCreateChunk(me, mmio, mmi, 0);
  68. }
  69.  
  70. void wrappedStartListChunk(char *me, HMMIO mmio, MMCKINFO *mmi, FOURCC ckid) {
  71.     mmi->cksize = 0;
  72.     mmi->fccType = ckid;
  73.  
  74.     wrappedCreateChunk(me, mmio, mmi, MMIO_CREATELIST);
  75. }
  76.  
  77. void wrappedAscend(char *me, HMMIO mmio, MMCKINFO *ckinfo, UINT flags) {
  78.     MMRESULT err;
  79.  
  80.     if (MMSYSERR_NOERROR != (err = mmioAscend(mmio, ckinfo, flags)))
  81. //        throw "Error finishing chunk!";
  82.         throw MyMMIOError(me,err);
  83. }
  84.  
  85. void wrappedDescend(char *me, HMMIO hmmio, LPMMCKINFO lpck, LPMMCKINFO lpckParent, UINT wFlags) {
  86.     MMRESULT err;
  87.  
  88.     if (MMSYSERR_NOERROR != (err = mmioDescend(hmmio, lpck, lpckParent, wFlags)))
  89. //        throw "Error finding chunk!";
  90.         throw MyMMIOError(me,err);
  91. }
  92.  
  93. void wrappedRead(char *me, HMMIO mmio, char *data, LONG len) {
  94.     LONG lActual;
  95.  
  96.     if (len != (lActual = mmioRead(mmio, data, len)))
  97. //        throw "Error reading data!";
  98.         if (lActual == -1)
  99.             throw MyError("%s error: couldn't read from file",me);
  100.         else
  101.             throw MyError("%s error:\npremature end of file\n(%ld bytes requested, %ld actually read)",me,len,lActual);
  102. }
  103.  
  104. void wrappedWrite(char *me, HMMIO mmio, char *data, LONG len) {
  105.     LONG lActual;
  106.  
  107.     if (len != (lActual = mmioWrite(mmio, data, len)))
  108. //        throw "Error writing data!";
  109.         if (lActual == -1)
  110.             throw MyError("%s error: couldn't write to file",me);
  111.         else
  112.             throw MyError("%s error: only %ld of %ld actually written",me,len,lActual);
  113. }
  114.  
  115. void wrappedWriteChunk(char *me, HMMIO mmio, FOURCC ckid, char *ckdata, LONG len) {
  116.     MMCKINFO mmi;
  117.  
  118.     mmi.ckid = ckid;
  119.     mmi.cksize=0;
  120.     wrappedCreateChunk(me, mmio, &mmi, 0);
  121.     wrappedWrite(me, mmio, ckdata, len);
  122.     wrappedAscend(me, mmio, &mmi, 0);
  123. }
  124.  
  125. LONG wrappedSeek(char *me, HMMIO mmio, LONG lOffset, int iOrigin) {
  126.     LONG lOldOffset;
  127.  
  128.     lOldOffset = mmioSeek(mmio, lOffset, iOrigin);
  129.  
  130.     if (lOldOffset == -1)
  131.         throw MyError("%s error: seek failure", me);
  132.  
  133.     return lOldOffset;
  134. }
  135.  
  136. LONG wrappedGetPosition(char *me, HMMIO mmio) {
  137.     MMRESULT err;
  138.     MMIOINFO mmi;
  139.  
  140.     wrappedFlush(me, mmio, MMIO_EMPTYBUF);
  141.  
  142.     if (err = mmioGetInfo(mmio, &mmi, 0))
  143.         throw MyMMIOError(me, err);
  144.  
  145.     return mmi.lDiskOffset;
  146. }
  147.  
  148.